<?php
App::uses('AppController', 'Controller');
/**
 * Sites Controller
 *
 * @property Site $Site
 */
class SitesController extends AppController {
	
	function admin_supprimerQuestionsAvecRegle() {
		$this->loadModel("Question");
		foreach ($this->data['question'] as $id => $v) {
			$this->Question->supprimerRegleQuestion($id);
		}
		$this->redirect(array('action' => 'editeurWysiwyg'));
	}
	
	function admin_traiterWysiwyg() {
		if($this->request->is('post')) {
			// chargement des modèles de données
			$this->loadModel('VoxBloc');
			$this->loadModel('BlocQuestion');
			$this->loadModel('Question');
			$this->loadModel('Reponse');
			$this->loadModel('StatutsReponse');
			// on commence par désactiver les blocs et les questions
			$this->VoxBloc->desactiverToutLesVoxBlocs();
			$this->BlocQuestion->desactiverToutLesBlocs();
			$this->Question->desactiverToutesLesQuestions();
			
			$out = array();
			
			// fonction interne permettant d'ajouter ou de retraiter une question
			// paramètres :
			// - context : le context de l'objet (this)
			// - rang : le rang de la question
			// - id : l'id de la question (si null, elle sera créé)
			// - type : le type de la question (valeurs possibles : 'TEXTE', 'ENTIER', 'ARTICLE', 'LISTE', 'OUINON')
			// - active : boolean indiquant si la question est active par défaut ou non
			// - id_bloc : l'id du bloc contenant cette question (si null, c'est une question sur societe)
			// - nom : le nom de la question
			// - reponses : les réponses pour cette question (dans le cas d'un type LISTE, sinon null)
			// - id_categorie : l'id de la categorie (dans le cas d'un type ARTICLE, sinon null)
			function ajouterOuMettreAJourQuestion($context, $rang, $id, $type, $active, $id_bloc, $nom, $reponses = null, $id_categorie = null) {
				// si un id existe, on se contente de remettre à jours les infos. Sinon, on crée la question.
				if($id == null) $context->Question->create();
				$context->Question->save(
					array(
						'Question' => array(
							($id != null ? 'id_question' : '') => $id,
							'rang_question' => $rang,
							'type_reponse' => $type,
							'active' => 1,
							'question_active_par_defaut' => $active,
							($id_bloc != null ? 'id_bloc' : '') => $id_bloc,
							'question_sur_societe' => ($id_bloc == null),
							'libelle_question' => $nom,
							($type == 'ARTICLE' ? 'id_categorie' : '') => $id_categorie,
							'formulaire_question' => 'SITE',
						)
					)
				);
				if($id == null) $id = $context->Question->id;
				
				// si cette question comporte des réponses (dans le cas d'une liste), on les ajoutes également
				if($reponses != null) {
					// on se prépare à collecter les ids
					$ids_reponse = Array();
					// on initialise le compteur pour les rangs
					$rang_reponse = 0;
					// on parcour les réponses
					foreach($reponses as $reponse) {
						// si la réponse existe déjà (a un id), alors on garde juste l'id, sinon on ajoute
						if(isset($reponse['id'])) $ids_reponse[] = $reponse['id'];
						else {
							// sinon, on ajoute cette réponse à la bdd
							$context->Reponse->create();
							$context->Reponse->save(
								array(
									'Reponse' => array(
										'rang_reponse' => $rang_reponse,
										'libelle_reponse_combo' => $reponse['nom'],
										'id_question' => $id,
										'id_statut_reponse' => $context->StatutsReponse->idStatutVide()
									)
								)
							);
							$ids_reponse[] = $context->Reponse->id;
						}
						$rang_reponse++;
					}
					// on supprime les réponses qui n'appartiennent pas a la liste pour cette question
					$context->Question->conserverReponses($id, $ids_reponse);
				}
				return $id;
			}
			/**** fin des fonctions internes ****/
			
			
			// on gère le cas des questions sur sociétés : les questions qui n'appartiennent à aucun voxbloc
			if(isset($this->data['questions'])) {
				$rang_question_societe = 0;
				foreach ($this->data['questions'] as $question) {
					ajouterOuMettreAJourQuestion($this, $rang_question_societe, isset($question['id']) ? $question['id'] : null, $question['type'], $question['active']=='true',
												 null, $question['nom'], isset($question['reponses']) ? $question['reponses'] : null, isset($question['val']) ? $question['val'] : null);
					$rang_question_societe++;
				}
			}
			
			// on initialise le compteur des voxblocs pour les rangs
			$rang_voxbloc = 0;
			// on parcours les voxblocs
			if(isset($this->data['voxblocs'])) {
				foreach ($this->data['voxblocs'] as $voxbloc) {
					// si un id existe, on se contente de réactiver le voxbloc et de mettre à jour son nom. Sinon, on crée le voxbloc
					if(!isset($voxbloc['id'])) $this->VoxBloc->create();
					$this->VoxBloc->save(
						array (
							'VoxBloc' => array (
								(isset($voxbloc['id']) ? 'id_vox_bloc' : '') => (isset($voxbloc['id']) ? $voxbloc['id'] : null),
								'libelle_vox_bloc' => $voxbloc['nom'],
								'rang_vox_bloc' => $rang_voxbloc,
								'active' => true,
								'updated' => isset($voxbloc['id']) ? true : false
							)
						)
					);
					$id_vox_bloc = $this->VoxBloc->id;
				
					// on incrémente le rang pour le prochain voxbloc
					$rang_voxbloc++;
					// on initialise le compteur des blocs pour les rangs
					$rang_bloc = 0;
					// on parcours les blocs
					if(isset($voxbloc['blocs'])) {
						foreach ($voxbloc['blocs'] as $bloc) {
							// si un id existe, alors on se contente de réactiver le bloc et de mettre à jours les informations. Sinon, on le crée
							if(!isset($bloc['id'])) $this->BlocQuestion->create();
							$this->BlocQuestion->save(
								array(
									'BlocQuestion' => array(
										(isset($bloc['id']) ? 'id_bloc' : '') => (isset($bloc['id']) ? $bloc['id'] : null),
										'rang_bloc' => $rang_bloc,
										'description_bloc' => $bloc['nom'],
										'id_vox_bloc' => $id_vox_bloc,
										'active' => true
									)
								)
							);
							$id_bloc = $this->BlocQuestion->id;
							
							// on incrément le rang pour le prochain bloc
							$rang_bloc++;
							// on initialise le compteur de question pour les rangs
							$rang_question = 0;
							// on parcours les questions
							if(isset($bloc['questions'])) {
								foreach ($bloc['questions'] as $question) {
									
									ajouterOuMettreAJourQuestion($this, $rang_question, isset($question['id']) ? $question['id'] : null, $question['type'], $question['active']=='true', $id_bloc,
																 $question['nom'], isset($question['reponses']) ? $question['reponses'] : null, isset($question['val']) ? $question['val'] : null);
									$rang_question++;
								}
							}
						}
					}
				}
			}
			
			// on supprime les règles qui sont attachées à des questions désactivés
			$this->Question->supprimerRegleDesQuestionsDesactivees();
		
			$questions_desactivees_avec_regle = $this->Question->questionsDesactiverAvecRegle();
			
			if(count($questions_desactivees_avec_regle) > 0) {
				$this->Question->activerQuestions($questions_desactivees_avec_regle);
				$this->set('listeQuestion', $this->Question->obtenirQuestions($questions_desactivees_avec_regle));
			}
			else {
				// redirection
				$this->Session->setFlash(__('Le formulaire a été mis à jour.'), 'flash_success');
				$this->redirect(array('action' => 'editeurWysiwyg'));
			}
		}
	}
	
	// en version alpha, permet d'éditer le formulaire en mode wysiwyg
	function admin_editeurWysiwyg() {
		// chargement des modèles
		$this->loadModel('Question');
		$this->loadModel('VoxBloc');
		$this->loadModel('ArticlesCategory');
		// chargement des données
		$questions_sites =$this->Question->toutesLesQuestionsSurSite();
		$blocs = $this->VoxBloc->obtenirToutLesBlocsEtLeursQuestions();
		$articles = $this->ArticlesCategory->toutesLesCategoriesEtLeursArticles();
		// mise a disposition des données pour la vue
		$this->set('questions_sites', $questions_sites);
		$this->set('questions_blocs', $blocs);
		$this->set('categories', $articles);
	}
	
	// ajoute une question dans la page finalisation du devis (comme la durée d'engagement par exemple)
	function admin_ajouterQuestionFinalisation() {
		if(isset($this->request->data['type_reponse'])
		&& isset($this->request->data['rang_question'])
		&& isset($this->request->data['libelle_question'])
		&& isset($this->request->data['question_active_par_defaut'])
		&& isset($this->request->data['formulaire_question'])) {
			$this->loadModel('Question');
			if($this->Question->saveAll($this->request->data)) {
				// tout est ok
				$this->layout = '';
				$this->set('id_question', $this->Question->getLastInsertID());
				$this->set('out', null);
				$this->set('success', true);
			}
		}
	}
	
	// ajoute une règle pour un question de la finalisation du devis (genre "durée engagement")
	// paramètres POST :
	// - id_article : id de l'article à ajouté
	// - id_reponses[] : l'ensemble des réponses conditionnant l'activation de cette règle
	// - questions[] : l'ensemble des questions servant à préciser la quantité (somme de ces réponses * coefficient). Format de questions :
	//	 {id_question, coefficient}
	// - prix_base : le tarif brut de l'article
	function admin_ajouterRegleFinalisation() {
		$this->loadModel('TarifCalcule');
		$this->loadModel('Tarif');
		$this->loadModel('QuantiteArticle');
		
		foreach($this->data['id_reponses'] as $id_reponse) {
			$this->Tarif->create();
			$this->Tarif->save(array(
									'tarif_article_brut' => $this->data['prix_base'],
									'id_reponse' => $id_reponse,
									'id_article' => $this->data['id_article'],
								));
			$idTarif = $this->Tarif->id;
		}
		
		if(isset($this->data['questions'])) {
			// on ajoute les questions avec leurs coefficients
			foreach($this->data['questions'] as $question) {
				$this->TarifCalcule->insertRegleTarif($idTarif, $question['coefficient'], $question['id_question']);
			}
		}
		
		$this->layout = '';
		$this->set('out', null);
		$this->set('success', true);
	}

	// ajout une règle de type 'ligne => ligne' dans la bdd
	// paramètres POST :
	// - id_article_declenchant : l'id de l'article qui déclenche la règle
	// - id_article_declenche : l'id de l'article à ajouté lors du déclenchement
	// - coefficient : coefficient de l'article à ajouté
	function admin_ajouterRegleLigneLigne() {
		$this->loadModel('ArticlesEnCascade');
		$this->ArticlesEnCascade->ajouterRegleLigneLigne($this->data['id_article_declenchant'], $this->data['id_article_declenche'], $this->data['coefficient']);
		$this->layout = '';
		$this->set('out', '');
		$this->set('success', 'true');
	}
	
	// supprimer une règle de type 'ligne => ligne' dans la bdd
	// paramètres POST :
	// - id_article_parent : l'id de l'article parent
	// - id_article_enfant : l'id de l'article enfant
	function admin_supprimerRegleLigneLigne() {
		$this->loadModel('ArticlesEnCascade');
		$this->ArticlesEnCascade->supprimerRegleLigneLigne($this->data['id_article_parent'], $this->data['id_article_enfant']);
		$this->layout = '';
		$this->set('result', '');
		$this->set('success', 'true');
	}
	
	// ajoute une règle de type 'reponse => article' dans la bdd
	// paramètres POST :
	// - id_article : id de l'article à ajouté
	// - fixe : boolean indiquant si la quantité est fixe ou calculé
	// - quantite : quantité à ajouté
	// - somme : boolean indiquant si la quantité est sommé entre les sites ou non
	// - id_reponses[] : l'ensemble des réponses conditionnant l'activation de cette règles
	// - questions[] : l'ensemble des questions servant à préciser la quantité (somme de ces réponses + coefficient). Format de questions :
	// 	{id_question, coefficient}
	function admin_ajouterRegleArticle() {
		
		$this->loadModel('AjoutLigne');
		$this->loadModel('DeclencheAjoutLigne');
		$this->loadModel('QuantiteArticle');
		
		$this->AjoutLigne->create();
		$this->AjoutLigne->save(array(
								'AjoutLigne' => array(
									'quantite_article' => ($this->data['fixe'] == 'true' ? $this->data['quantite'] : null),
									'id_article' => $this->data['id_article'],
									'nonsomme' => $this->data['somme'] == 'true' ? false:true
								)));
		$id_ajoutligne = $this->AjoutLigne->id;
		
		// on ajoute les questions conditionnant
		foreach ($this->data['id_reponses'] as $id_reponse) {
			$this->DeclencheAjoutLigne->ajouter($id_reponse, $id_ajoutligne);
		}
		
		// si ce n'est pas fixe, on ajoute les questions avec leurs coefficients
		if($this->data['fixe'] == 'false') {
			foreach($this->data['questions'] as $question) {
				$this->QuantiteArticle->ajouter($id_ajoutligne, $question['id_question'], $question['coefficient']);
			}
		}
		
		$this->layout = '';
		$this->set('out', null);
		$this->set('success', true);
	}
	
	// ajoute une règle de type 'reponse => reponse' dans la bdd
	// paramètres POST :
	// - id_reponse_affectant : id de la réponse affectante
	// - id_reponse_affectee : id de la réponse affectée
	// - id_statut : l'id du nouveau statut
	function admin_ajouterRegleReponse() {
		$this->loadModel('NouveauStatut');
		
		$result = $this->NouveauStatut->creer_ou_mettre_a_jour($this->request->data['id_reponse_affectant'], $this->request->data['id_reponse_affectee'], $this->request->data['id_statut']);
		$this->set('success', true);
		$this->set('result', $result);
		$this->layout = '';
	}
	
	// ajoute une réponse dans la bdd
	// attends les paramètres de requête suivant :
	// - question : l'id de la question pour laquelle on ajoute la réponse
	// - type : le type de la réponse à ajouter. Les paramètres suivants dépendent du type :
	//	- entier :
	//		- min : valeur minimale de l'entier
	//		- max : valeur maximale de l'entier
	//	- article :
	//		- article : id de l'article correspondant
	// 	- liste :
	// 		- libelle : le nom de l'élément
	// 	- ouinon :
	// 		- reponse : 'oui' ou 'non'
	function admin_ajouterReponse() {
		// chargement du model des statuts et des réponses
		$this->loadModel('Reponse');
		$this->loadModel('StatutsReponse');
		// récupération de l'id de la statut_reponse vide
		$id_statut_reponse_vide = $this->StatutsReponse->find('first', array('fields' => 'id_statut_reponse', 'conditions' => array('libelle_statut_reponse' => '')));
		$id_statut_reponse_vide = $id_statut_reponse_vide['StatutsReponse']['id_statut_reponse'];

		$type = strtolower($this->request->data['type']);
		// on agit en fonction du type de la réponse à ajouter
		switch($type) {
			case 'liste':
				$reponse = $this->Reponse->find('first', array('recursive' => -1, 'conditions' => array('libelle_reponse_combo' => $this->request->data['libelle'], 'id_question' => $this->request->data['question'])));
				if(!$reponse){
					$this->Reponse->create();
					$this->Reponse->set('libelle_reponse_combo', $this->request->data['libelle']);
					$this->Reponse->set('id_question', $this->request->data['question']);
					$this->Reponse->set('id_statut_reponse', $id_statut_reponse_vide);
					$this->Reponse->save();
					$id_reponse = $this->Reponse->getInsertId();
				}
				else {
					$id_reponse = $reponse['Reponse']['id_reponse'];
				}
				break;
			case 'ouinon':
				$reponse = $this->Reponse->find('first', array('recursive' => -1, 'conditions' => array('reponse_oui_non' => $this->request->data['reponse'] == 'oui', 'id_question' => $this->request->data['question'])));
				if(!$reponse){
					$this->Reponse->create();
					$this->Reponse->set('reponse_oui_non', $this->request->data['reponse'] == 'oui');
					$this->Reponse->set('id_question', $this->request->data['question']);
					$this->Reponse->set('id_statut_reponse', $id_statut_reponse_vide);
					$this->Reponse->save();
					$id_reponse = $this->Reponse->getInsertId();
				}
				else {
					$id_reponse = $reponse['Reponse']['id_reponse'];
				}
				break;
			case 'entier':
				$reponse = $this->Reponse->find('first', array('recursive' => -1, 'conditions' => array('id_question' => $this->request->data['question'], 'valeur_min' => $this->request->data['min'], 'valeur_max'=>  $this->request->data['max'])));
				if(!$reponse) {
					$this->Reponse->create();
					$this->Reponse->set('valeur_min', $this->request->data['min']);
					$this->Reponse->set('valeur_max', $this->request->data['max']);
					$this->Reponse->set('id_question', $this->request->data['question']);
					$this->Reponse->set('id_statut_reponse', $id_statut_reponse_vide);
					$this->Reponse->save();
					$id_reponse = $this->Reponse->getInsertId();
				}
				else {
					$id_reponse = $reponse['Reponse']['id_reponse'];
				}
				break;
			case 'article':
				$reponse = $this->Reponse->find('first', array('recursive' => -1, 'conditions' => array('id_question' => $this->request->data['question'], 'id_article' => $this->request->data['article'])));
				if(!$reponse) {
					$this->Reponse->create();
					$this->Reponse->set('id_article', $this->request->data['article']);
					$this->Reponse->set('id_question', $this->request->data['question']);
					$this->Reponse->set('id_statut_reponse', $id_statut_reponse_vide);
					$this->Reponse->save();
					$id_reponse = $this->Reponse->getInsertId();
				}
				else {
					$id_reponse = $reponse['Reponse']['id_reponse'];
				}
				break;
		}
		
		// écriture de l'id sur la sortie
		$this->layout = '';
		$this->set('id_reponse', $id_reponse);
	}

	// ajoute une regle dans la bdd
	// attends les paramètres de requête suivant :
	// - id_question : l'id de la question affecté
	// - id_reponse : l'id de la réponse qui agit
	// - action : le type de l'action ('active' ou 'desactive')
	public function admin_ajouterRegle() {
		// définition du retour comme étant du json sans vue
		$this->layout = '';
		$this->set('out', null);
		// verification de la présence de tout les paramètres
		if(isset($this->request->data['id_question'])
		&& isset($this->request->data['id_reponse'])
		&& isset($this->request->data['action'])) {
			$this->loadModel('ActionQuestion');
			$this->ActionQuestion->creer_ou_mettre_a_jour($this->request->data['id_question'],$this->request->data['id_reponse'], $this->request->data['action']);
		}
		
		// tout est ok
		$this->set('success', true);
	}
	
	public function admin_supprimerRegleTarif() {
		$this->loadModel("Tarif");
		$this->loadModel("TarifCalcule");
		$this->TarifCalcule->peterLeTarifCalcule($this->request->data['id_tarif']);
		$this->Tarif->peterLeTarif($this->request->data['id_tarif']);
		$this->layout ='';
	}
	
	
	public function admin_supprimerRegle() {
		$this->loadModel("ActionQuestion");
		$this->ActionQuestion->detruire_par_les_id($this->request->data['id_reponse'], $this->request->data['id_question']);
		$this->layout ='';
		$this->autoRender = false;
	}
	
	public function admin_supprimerNouveauStatut() {
		$this->loadModel("NouveauStatut");
		$this->NouveauStatut->detruire_par_les_id($this->request->data['id_reponse'], $this->request->data['id_reponse_cible']);
		$this->layout ='';
		$this->autoRender = false;
	}
	
	// permet de supprimer une règle de type reponse/article
	// paramètres :
	// - id_ajout_ligne : l'id de l'ajout ligne à supprimer
	public function admin_supprimerReponseArticle() {
		$this->loadModel("AjoutLigne");
		
		$this->AjoutLigne->supprimerRegleReponseArticle($this->data['id_ajout_ligne']);
		
		$this->layout ='';
	}
	
	public function admin_supprimerQuestionDevis() {
		$this->loadModel("Question");
		$this->Question->supprimerQuestionDevis($this->data['id_question']);
		$this->layout = '';
	}
	
	public function admin_gererRegles() {
		// on charge les modèles nécessaire
		$this->loadModel("Question");
		$this->loadModel("ArticlesCategory");
		$this->loadModel("StatutsReponse");
		$this->loadModel("Reponse");
		$this->loadModel("ActionQuestion");
		$this->loadModel("AjoutLigne");
		$this->loadModel("ArticlesEnCascade");
		$this->loadModel("Tarif");
		
		//$this->set('questionsConflitsRegles', $this->Site->questions_plusieurs_regles());
		
		$this->set('tab_regles', $this->ActionQuestion->recap_regles());
		$this->set('tab_reponses', $this->ActionQuestion->recap_reponses());
		$this->set('tab_regles_gen_devis', $this->AjoutLigne->obtenirListe());
		$this->set('tab_regles_ligne_ligne', $this->ArticlesEnCascade->obtenirListe());
		$this->set('questions_finalisation', $this->Question->questionsEtReponsesFinalisation());
		$this->set('regles_finalisation', $this->Tarif->reglesTarifs());
		
		if($this->request->is('get')) {
			// $this->set('reglesConflits', $this->Question->questionsReglesConflits());
			$this->set('questions', $this->Question->toutesLesQuestionsEtLeursReponses());
			$this->set('questions_article_entier', $this->Question->toutesLesQuestionsEtLeursReponses(array('ENTIER', 'ARTICLE')));
			$this->set('questions_article_entier_ouinon', $this->Question->toutesLesQuestionsEtLeursReponses(array('ENTIER', 'ARTICLE', 'OUINON')));
			
			$this->set('categories', $this->ArticlesCategory->toutesLesCategoriesEtLeursArticles());
			$this->set('statuts', $this->StatutsReponse->find('all', array('recursive' => 0)));
			$this->set('var', array('questions' => $this->Question->toutesLesQuestionsEtLeursReponses(), 'categories' => $this->ArticlesCategory->toutesLesCategoriesEtLeursArticles(), 'statuts' => $this->StatutsReponse->find('all', array('recursive' => 0))));
		}
	}

	public function admin_gererFormulaire() {
		// on charge les modèles nécessaires au traitement
		$this->loadModel("ActionQuestion");
		$this->loadModel("Article");
		$this->loadModel("ArticlesCategory");
		$this->loadModel("BlocQuestion");
		$this->loadModel("Devi");
		$this->loadModel("NouveauStatut");
		$this->loadModel("Question");
		$this->loadModel("Questionnaire");
		$this->loadModel("Reponse");
		$this->loadModel("StatutsReponse");
		$this->loadModel("ReponsesDonnee");
		$this->loadModel("VoxBloc");
		
		if($this->request->is('get')) {
			$blocs = $this->VoxBloc->trouverToutLesBlocsEtLeursQuestions();
			$this->set('questions', $blocs);
			// récupération de l'ensemble des articles et leurs catégories
			$articles = $this->ArticlesCategory->toutesLesCategoriesEtLeursArticles();
			$this->set('categories', $articles);
			$this->set('var', $blocs);
		}
		
		if($this->request->is('post')) {
			
			$test = '';
			
			// variable contenant le texte pour les erreurs
			$erreur = array();
			
			// parcours des blocs pour vérification de non erreur
			if(isset($this->data['bloc'])) {
				foreach ($this->data['bloc'] as $bloc) {
					// parcours des ensembles
					if(isset($bloc['ensemble'])) {
						foreach ($bloc['ensemble'] as $ensemble) {
							// parcours des inputs
							if(!isset($ensemble['input'])) $erreur[] = 'Un ensemble doit contenir au moins un élément.';
						}
					} else $erreur[] = 'Un bloc doit contenir au moins un ensemble.';
				}
			} else $erreur[] = 'Vous devez créer au moins un bloc.';
			
			// affichage des erreurs si nécessaire
			if(count($erreur) > 0) {
				$out_erreur = '';
				for ($i = 0; $i < count($erreur); $i++) {
					if($i > 0) $out_erreur .= '<br />';
					$out_erreur .= $erreur[$i];
				}
				$this->Session->setFlash($out_erreur);
			}
			else {
				// suppression des éléments voulut
				// voxbloc
				if(isset($this->data['removeBloc'])) {
					foreach($this->data['removeBloc'] as $removeBloc) {
						$ensembles = $this->BlocQuestion->find('list', array('conditions'=> array('BlocQuestion.id_vox_bloc' => $removeBloc)));
						
						// requete provisoire a changé rapidement !!!!!!!
						foreach($ensembles as $id_ensemble => $ensemble) {
							$questions = $this->Question->find('list', array('conditions' => array('Question.id_bloc' => $id_ensemble)));
							foreach($questions as $id_question => $question) {
								$reponses = $this->Reponse->find('list', array('recursive'=>0, 'conditions' => array('Reponse.id_question' => $id_question)));
								foreach($reponses as $id_reponse => $reponse) {
									$this->ActionQuestion->removeByIdReponse($id_reponse);
									$this->NouveauStatut->detruire_par_id_reponse($id_reponse);
									$this->NouveauStatut->detruire_par_id_reponse_statut_change_par($id_reponse);
								}
								$this->Reponse->deleteAll(array('Reponse.id_question' => $id_question));
							}
							$this->Question->deleteAll(array('Question.id_bloc' => $id_ensemble));
							$this->BlocQuestion->delete($id_ensemble);
						}
						$this->VoxBloc->delete($removeBloc);
					}
				}
				// ensemblebloc
				if(isset($this->data['removeEnsemble'])) {
					foreach($this->data['removeEnsemble'] as $removeEnsemble) {
						$questions = $this->Question->find('list', array('recursive'=>0, 'conditions' => array('Question.id_bloc' => $removeEnsemble)));
						foreach($questions as $id_question => $question) {
							$reponses = $this->Reponse->find('list', array('recursive'=>0, 'conditions' => array('Reponse.id_question' => $removeQuestion)));
							foreach($reponses as $id_reponse => $reponse) {
								$this->ActionQuestion->removeByIdReponse($id_reponse);
								$this->NouveauStatut->detruire_par_id_reponse($id_reponse);
								$this->NouveauStatut->detruire_par_id_reponse_statut_change_par($id_reponse);
							}
							$this->ActionQuestion->removeByIdQuestion($id_question);
						}
						$this->Question->deleteAll(array('Question.id_bloc' => $removeEnsemble));
						$this->BlocQuestion->delete($removeEnsemble);
					}
				}
				// question
				if(isset($this->data['removeQuestion'])) {
					foreach($this->data['removeQuestion'] as $removeQuestion) {
						$reponses = $this->Reponse->find('list', array('recursive'=>0, 'conditions' => array('Reponse.id_question' => $removeQuestion)));
						foreach($reponses as $id_reponse => $reponse) {
							$this->ActionQuestion->removeByIdReponse($id_reponse);
							$this->NouveauStatut->detruire_par_id_reponse($id_reponse);
							$this->NouveauStatut->detruire_par_id_reponse_statut_change_par($id_reponse);
						}
						$this->ActionQuestion->removeByIdQuestion($removeQuestion);
						$this->Reponse->deleteAll(array('Reponse.id_question' => $removeQuestion));
						$this->Question->delete($removeQuestion);
					}
				}
				// reponse
				if(isset($this->data['removeReponse'])) {
					foreach($this->data['removeReponse'] as $removeReponse) {
						$this->ActionQuestion->removeByIdReponse($removeReponse);
						$this->NouveauStatut->detruire_par_id_reponse($removeReponse);
						$this->NouveauStatut->detruire_par_id_reponse_statut_change_par($removeReponse);
						$this->Reponse->delete($removeReponse);
					}
				}
				
				// récupération de l'id de la statut_reponse vide
				$id_statut_reponse_vide = $this->StatutsReponse->find('first', array('fields' => 'id_statut_reponse', 'conditions' => array('libelle_statut_reponse' => '')));
				$id_statut_reponse_vide = $id_statut_reponse_vide['StatutsReponse']['id_statut_reponse'];
				// parcours des blocs et enregistrement dans la bdd des blocs, ensembles et inputs
				$rang_bloc = 1;
				foreach ($this->data['bloc'] as $bloc) {
					// création et enregistrement du bloc
					// si il existe déjà, on le met à jour
					if(isset($bloc['id'])) {
						$this->VoxBloc->save(array('id_vox_bloc' => $bloc['id'], 'libelle_vox_bloc' => $bloc['nom'], 'rang_vox_bloc' => $rang_bloc));
						$id_bloc = $bloc['id'];
					}
					// si il n'existe pas encore, on le crée
					else {
						$this->VoxBloc->create();
						$this->VoxBloc->set('rang_vox_bloc', $rang_bloc);
						$this->VoxBloc->set('libelle_vox_bloc', $bloc['nom']);
						$this->VoxBloc->save();
						$id_bloc = $this->VoxBloc->getInsertId();
					}
					$rang_bloc ++;
					// parcours des ensembles
					$rang_ensemble = 1;
					foreach ($bloc['ensemble'] as $ensemble) {
						// si l'ensemble existe déjà, on le met à jour
						if(isset($ensemble['id'])) {
							$this->BlocQuestion->save(array('id_bloc' => $ensemble['id'], 'id_vox_bloc' => $id_bloc, 'description_bloc' => $ensemble['nom'], 'rang_bloc' => $rang_ensemble));
							$id_ensemble = $ensemble['id'];
						}
						// si l'ensemble n'existe pas, on le crée
						else {
							$this->BlocQuestion->create();
							$this->BlocQuestion->set('id_vox_bloc', $id_bloc);
							$this->BlocQuestion->set('rang_bloc', $rang_ensemble);
							$this->BlocQuestion->set('description_bloc', $ensemble['nom']);
							$this->BlocQuestion->save();
							$id_ensemble = $this->BlocQuestion->getInsertId();
						}
						$rang_ensemble ++;
						// parcours des inputs
						$rang_question = 1;
						foreach($ensemble['input'] as $input) {
							// si l'input existe déjà, on le met à jour
							if(isset($input['id'])) {
								$this->Question->save(array('id_question' => $input['id'], 'libelle_question' => $input['val'], 'type_reponse' => $input['type'], 'question_active_par_defaut' => isset($input['question_active_par_defaut']), 'rang_question' => $rang_question));
								$id_question = $input['id'];
							}
							// si l'input n'existe pas, on le crée
							else {
								$this->Question->create();
								$this->Question->set('id_bloc', $id_ensemble);
								$this->Question->set('rang_question', $rang_question);
								$this->Question->set('libelle_question', $input['val']);
								$this->Question->set('type_reponse', $input['type']);
								$this->Question->set('question_active_par_defaut', isset($input['question_active_par_defaut']));
								$this->Question->save();
								$id_question = $this->Question->getInsertId();
							}
							$rang_question ++;
							
							// si c'est une LISTE
							if($input['type'] == 'LISTE') {
								// parcours des options de la liste
								$rang_reponse = 1;
								foreach($input['liste'] as $liste) {
									// si la réponse n'existe pas déjà, on la crée, sinon on la laisse tel quel
									if(!isset($liste['id'])) {
										$this->Reponse->create();
										$this->Reponse->set('rang_reponse', $rang_reponse++);
										$this->Reponse->set('libelle_reponse_combo', $liste['val']);
										$this->Reponse->set('id_question', $id_question);
										$this->Reponse->set('id_statut_reponse', $id_statut_reponse_vide);
										$this->Reponse->save();
									}
								}
							}
							// si c'est un ARTICLE
							if($input['type'] == 'ARTICLE') {
								// on rajoute l'id de la categorie choisie
								$this->Question->save(array('id_question' => $id_question, 'id_categorie' => $input['categorie']));
							}
						}
					}
				}
			}
		}
	}
	
	public function creer() {
		$this->loadModel('ReponsesDonnee');
		$this->loadModel('Question');
		$this->loadModel('Questionnaire');
		$this->loadModel('Devi');
		$this->loadModel('LigneDevi');
		$services = $this->Site->questions_a_afficher();
		$questionscombos = $this->Site->recup_reponses_listes();
		$questionsavecarticles = $this->Site->recuperer_articles();
		$questions_sites = $this->Question->toutesLesQuestionsSurSite();
		$this->set('services', $services);
		$this->set('questionscombos', $questionscombos);
		$this->set('questionsavecarticles', $questionsavecarticles);
		$this->set('questions_sites', $questions_sites);
		$this->set('nb_site', $this->Session->read('utilisateur.nombre_de_site'));
		
		if($this->request->is('get')) {
			// affichage du questionnaire côté revendeur
			$this->set('id_questionnaire', $this->Session->read('utilisateur.id_questionnaire'));
		}
		else if($this->request->is('post')) {
			// création d'un nouveau devis, envoi du questionnaire et enregistrement de ses réponses
			$nb_ref = $this->Devi->find('count');
			if($nb_ref == 10000) {
				$nb_ref = 0;
			}
			$this->Devi->create();
			$this->Devi->save(array('id_utilisateur' => $this->Session->read('utilisateur.id'),
									'id_societe' => $this->Session->read('utilisateur.id_societe'),
									'date_creation' => date("Y-m-d H:m:s"),
									'statut_devis' => 'en attente',
									'statut_perso' => 'en attente',
									'ref_devis' => date('dmy').'-'.str_pad(strval($nb_ref+1), 4, "0", STR_PAD_LEFT)
								));
			$idDevi = $this->Devi->getInsertID();
			$this->Session->write('utilisateur.id_devis', $idDevi);
			
			$this->set('data', $this->request->data);
			
			foreach($this->request->data['site'] as $k => $v) {
				$this->request->data['site'][$k]['id_societe'] = $this->Session->read('utilisateur.id_societe');
			}
			
			// destruction des réponses existantes pour ce questionnaires
			$this->Questionnaire->peterReponseAvecId($this->Session->read('utilisateur.id_questionnaire'));
			
			// enregistrement de chaque site et leurs réponses
			foreach($this->request->data['site'] as $site) {
				$this->Site->create();
				$this->Site->save($site);
				$idSite = $this->Site->getInsertID();
				
				if(isset($site['question'])) {
					// parcours des questions qui ne sont pas dans un bloc
					foreach($site['question'] as $idQuestionDehors => $questionDehors) {
						if($questionDehors['active']) {
							switch($questionDehors['type']) {
								case 'ARTICLE' :
									// parcours des différents articles pour la même question
									foreach($questionDehors['qte'] as $k => $v) {
										$this->ReponsesDonnee->create();
										$this->ReponsesDonnee->save(array('id_questionnaire' => $this->Session->read('utilisateur.id_questionnaire'),
																	'id_question' => $idQuestionDehors,
																	'id_site' => $idSite,
																	'reponse_quantite_article' => $v,
																	'id_article' => $questionDehors['art'][$k]
																));
									}
								break;
								case 'ENTIER' :
									$this->ReponsesDonnee->create();
									$this->ReponsesDonnee->save(array('id_questionnaire' => $this->Session->read('utilisateur.id_questionnaire'),
																	'id_question' => $idQuestionDehors,
																	'id_site' => $idSite,
																	'reponse_entier' => $questionDehors['val']
																));
								break;
								case 'LISTE' :
									$this->ReponsesDonnee->create();
									$this->ReponsesDonnee->save(array('id_questionnaire' => $this->Session->read('utilisateur.id_questionnaire'),
																	'id_question' => $idQuestionDehors,
																	'id_site' => $idSite,
																	'id_reponse' => $questionDehors['val']
																));
								break;
								case 'OUINON' :
									$this->ReponsesDonnee->create();
									$this->ReponsesDonnee->save(array('id_questionnaire' => $this->Session->read('utilisateur.id_questionnaire'),
																	'id_question' => $idQuestionDehors,
																	'id_site' => $idSite,
																	'reponse_donnee_oui_non' => ($questionDehors['val'] == "OUI")
																));
								break;
								case 'TEXTE' :
									$this->ReponsesDonnee->create();
									$this->ReponsesDonnee->save(array('id_questionnaire' => $this->Session->read('utilisateur.id_questionnaire'),
																	'id_question' => $idQuestionDehors,
																	'id_site' => $idSite,
																	'reponse_donnee_texte' => $questionDehors['val']
																));
								break;
								default :
								break;
							}
						}
					}
				}
				
				// parcours des blocs dans les sites
				foreach($site['bloc'] as $idBloc => $bloc) {
					if($bloc['active']) {
						// parcours des questions du bloc si ce dernier est activé
						foreach($bloc['question'] as $idQuestion => $question) {
							// création et enregistrement de chaque réponse donnée si elle est activée
							if($question['active']) {
								switch($question['type']) {
									case 'ARTICLE' :
										// parcours des différents articles pour la même question
										foreach($question['qte'] as $k => $v) {
											$this->ReponsesDonnee->create();
											$this->ReponsesDonnee->save(array('id_questionnaire' => $this->Session->read('utilisateur.id_questionnaire'),
																		'id_question' => $idQuestion,
																		'id_site' => $idSite,
																		'reponse_quantite_article' => $v,
																		'id_article' => $question['art'][$k]
																	));
										}
									break;
									case 'ENTIER' :
										$this->ReponsesDonnee->create();
										$this->ReponsesDonnee->save(array('id_questionnaire' => $this->Session->read('utilisateur.id_questionnaire'),
																		'id_question' => $idQuestion,
																		'id_site' => $idSite,
																		'reponse_entier' => $question['val']
																	));
									break;
									case 'LISTE' :
										$this->ReponsesDonnee->create();
										$this->ReponsesDonnee->save(array('id_questionnaire' => $this->Session->read('utilisateur.id_questionnaire'),
																		'id_question' => $idQuestion,
																		'id_site' => $idSite,
																		'id_reponse' => $question['val']
																	));
									break;
									case 'OUINON' :
										$this->ReponsesDonnee->create();
										$this->ReponsesDonnee->save(array('id_questionnaire' => $this->Session->read('utilisateur.id_questionnaire'),
																		'id_question' => $idQuestion,
																		'id_site' => $idSite,
																		'reponse_donnee_oui_non' => ($question['val'] == 'OUI')
																	));
									break;
									case 'TEXTE' :
										$this->ReponsesDonnee->create();
										$this->ReponsesDonnee->save(array('id_questionnaire' => $this->Session->read('utilisateur.id_questionnaire'),
																		'id_question' => $idQuestion,
																		'id_site' => $idSite,
																		'reponse_donnee_texte' => $question['val']
																	));
									break;
									default :
									break;
								}
							}
						}
					}
				}
			}
			// tout est ok dans le questionnaire, on stocke les reponses dans une variable de session et on redirige vers le devis à completer "manuellement"
			$this->Session->setFlash('Toutes les informations ont été enregistrées.', 'flash_success');
			//$this->Session->write('utilisateur.reponses_questionnaire', $this->request->data);
			$this->redirect(array('controller' => 'devis', 'action' => 'finalisation'));
		}
	}

/**
 * admin_index method
 *
 * @return void
 */
	public function admin_index() {
		$this->Site->recursive = 0;
		$this->set('sites', $this->paginate());
	}

/**
 * admin_view method
 *
 * @param string $id
 * @return void
 */
	public function admin_view($id = null) {
		$this->Site->id = $id;
		if (!$this->Site->exists()) {
			throw new NotFoundException(__('Invalid site'));
		}
		$this->set('site', $this->Site->read(null, $id));
	}

/**
 * admin_add method
 *
 * @return void
 */
	public function admin_add() {
		if ($this->request->is('post')) {
			$this->Site->create();
			if ($this->Site->save($this->request->data)) {
				$this->Session->setFlash(__('Le site a été enregistré.', 'flash_success'));
				$this->redirect(array('action' => 'index'));
			} else {
				$this->Session->setFlash(__('Le site n\'a pas été enregistré. Merci de réessayer.'));
			}
		}
	}

/**
 * admin_edit method
 *
 * @param string $id
 * @return void
 */
	public function admin_edit($id = null) {
		$this->Site->id = $id;
		if (!$this->Site->exists()) {
			throw new NotFoundException(__('Invalid site'));
		}
		if ($this->request->is('post') || $this->request->is('put')) {
			if ($this->Site->save($this->request->data)) {
				$this->Session->setFlash(__('Le site a été enregistré.', 'flash_success'));
				$this->redirect(array('action' => 'index'));
			} else {
				$this->Session->setFlash(__('Le site n\'a pas été enregistré. Merci de réessayer.'));
			}
		} else {
			$this->request->data = $this->Site->read(null, $id);
		}
	}

/**
 * admin_delete method
 *
 * @param string $id
 * @return void
 */
	public function admin_delete($id = null) {
		if (!$this->request->is('post')) {
			throw new MethodNotAllowedException();
		}
		$this->Site->id = $id;
		if (!$this->Site->exists()) {
			throw new NotFoundException(__('Site invalide'));
		}
		if ($this->Site->delete()) {
			$this->Session->setFlash(__('Site supprimé', 'flash_success'));
			$this->redirect(array('action' => 'index'));
		}
		$this->Session->setFlash(__('Le site n\'a pas été supprimé, merci de réessayer.'));
		$this->redirect(array('action' => 'index'));
	}
}
